#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include "glm.h"

#if defined (__APPLE__) || defined(MACOSX)
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif




GLfloat LuzAmbiente[]   = {0.0f, 0.1f, 0.0f } ;
	GLfloat LuzDifusa[]   = {0.9f, 0.9f, 0.9f, 1.0f };
	GLfloat LuzEspecular[] = {0.8f, 0.8f, 0.8f, 1.0f };
	//GLfloat PosicaoLuz0[]  = {3.0f, 3.0f, 0.0f, 1.0f };
	GLfloat PosicaoLuz1[]  = {-3.0f, -3.0f, 0.0f, 1.0f };
	GLfloat Especularidade[] = {1.0f, 1.0f, 1.0f, 1.0f };



  /* Font data */

typedef struct ponto {
		float posZ;
		float posX;
		float posY;
	} Ponto;
	
Ponto * ponto1;
Ponto * ponto2; 
float posicaoX=0,posicaoY=0,posicaoZ=0;
float meuX = 0, meuY = 0, meuZ = 0;
int meuPontoX=0,meuPontoZ=0;
int flag = 1;
Ponto * pontoInicial;
int iheight, iwidth,qtdTriangulos,iheightTextura,iwidthTextura;
unsigned char* image = NULL; 
float alturaInicial, amplitudeAltura,distanciaPonto;
Ponto *** MatrizPontos;
Ponto* criaPonto(float posZ, float posX, float posY);
void mapeiaImagem();	
float mapeiaAltura(int tomCinza);
int isAndando = 0;
void imprimeMatrizPontos();
void gerenciaMouse(int button, int state, int x, int y);
void alteraTamanhoJanela(GLsizei w, GLsizei h);
void inicializa (void);
void desenha(void);
void especificaParametrosVisualizacao(void);
GLfloat angle, fAspect;
float maiorAltura ;
float maiorX, maiorZ,menorX,menorZ,menorY, alturaPessoa = 150;
float velocidade=100.0f;
Ponto* pontoMaiorAltura;
void reduzParaUnitario(Ponto *vector );
Ponto *calculaNormal(  Ponto   *p1,  Ponto   *p2,   Ponto   *p3 );
Ponto* calculaNormalVertice(Ponto* normal1,Ponto* normal2,Ponto* normal3,Ponto* normal4,Ponto* normal5,Ponto* normal6);
GLfloat	rtri=0.0f;
int typeVisualizacao = 0;
static GLuint texName[4];
//ParÃ¢metros da textura
int alturaMaximaAguaProfunda = -20;
int alturaMaximaAguaRasa = 10;
int alturaMaximaGrama = 70;
void mudaModoVisualizacao();



float mapeiaAltura(int tomCinza){
   return alturaInicial + (tomCinza * amplitudeAltura);
   
}
void funcPousar(){
  meuY = MatrizPontos[meuPontoX][meuPontoZ]->posY + alturaPessoa;
}


void reduzParaUnitario(Ponto *vector )
        {
        GLfloat length;

        // Calculate the length of the vector
        length = (GLfloat) sqrt((vector->posX * vector->posX) + (vector->posY * vector->posY) + (vector->posZ * vector->posZ));

        // Keep the program from blowing up by providing an exceptable
        // value for vectors that may calculated too close to zero.
        if (length == 0.0f)
            length =  1.0f;

        // Dividing each element by the length will result in a
        // unit normal vector.
        vector->posX = vector->posX / length;
        vector->posY = vector->posY / length;
        vector->posZ = vector->posZ / length;
        }


Ponto *calculaNormal(  Ponto   *p1,  Ponto   *p2,   Ponto   *p3 )
{
  Ponto* v1,*v2,*normal;
 	/* Encontra vetor v1 e v2*/
  v1 = criaPonto((p2->posX - p1->posX),(p2->posY - p1->posY),(p2->posZ - p1->posZ));
  v2 = criaPonto((p3->posX - p1->posX),(p3->posY - p1->posY),(p3->posZ - p1->posZ)); 
  normal = criaPonto(((v1->posY * v2->posZ) - (v1->posZ * v2->posY)),((v1->posZ * v2->posX) - (v1->posX * v2->posZ)),((v1->posX * v2->posY) - (v1->posY * v2->posX)));
  /* Calculo do produto vetorial de v1 e v2 */
  free(v1);
  free(v2);
  reduzParaUnitario(normal);
  return normal;
}

Ponto* calculaNormalVertice(Ponto* normal1,Ponto* normal2,Ponto* normal3,Ponto* normal4,Ponto* normal5,Ponto* normal6)
{
	float x,y,z;
	x= 0;
	y = 0;
	z = 0;
	int quantidade = 0;
	
	if(normal1 != NULL){
		x = x + normal1->posX;
		y = y + normal1->posY;
		z = z + normal1->posZ;
		quantidade++;
	}
	
	if(normal2 != NULL){
		x = x + normal2->posX;
		y = y + normal2->posY;
		z = z + normal2->posZ;
		quantidade++;
	}
	
	if(normal3 != NULL){
		x = x + normal3->posX;
		y = y + normal3->posY;
		z = z + normal3->posZ;
		quantidade++;
	}
	
	if(normal4 != NULL){
		x = x + normal4->posX;
		y = y + normal4->posY;
		z = z + normal4->posZ;
		quantidade++;
	}
	
	
	if(normal5 != NULL){
		x = x + normal5->posX;
		y = y + normal5->posY;
		z = z + normal5->posZ;
		quantidade++;
	}
	
	if(normal6 != NULL){
		x = x + normal6->posX;
		y = y + normal6->posY;
		z = z + normal6->posZ;
		quantidade++;
	}
	Ponto * normal = criaPonto(x/quantidade,y/quantidade,z/quantidade);
	reduzParaUnitario(normal);
	return normal; ;
}              

Ponto* criaPonto(float posX, float posY, float posZ)
{
	Ponto* point = (Ponto*)malloc(sizeof(Ponto));
	point->posX = posX;
	point->posY = posY;
	point->posZ = posZ;
	return point;
}


//FunÃ§Ã£o que desenha os triÃ¢ngulos
void desenhaTriangulos(void)
{   
	int textura;
	int isNewLine = 0;
	float coordX = 0;
	float coordY = 0;
   	int x, y,indexTriangulo;
	indexTriangulo = 0;
	int aux = 0;
		
	for(x= 0; x < iheight -1; x++){
     
     if(x < iheight/5){
		 glBindTexture(GL_TEXTURE_2D, texName[4]);
	 }
	 
	  else if(x < iheight/3){
		 glBindTexture(GL_TEXTURE_2D, texName[3]);
	 }
	 else{
		  glBindTexture(GL_TEXTURE_2D, texName[2]);
	 }
     glBegin( GL_TRIANGLE_STRIP );
   
	float coordY = 0;
    for(y= 0; y < iwidth ; y++){
      int pX = x;
      int pY = y;
      Ponto* normal1,*normal2,*normal3,*normal4,*normal5,*normal6,*normalR;
      normal1 = NULL;
      normal2 = NULL;
      normal3 = NULL;
      normal4 = NULL;
      normal5= NULL;
      normal6 = NULL;
      normalR = NULL;
      //Regiao 1
      if((pY>0 && pY< (iwidth -1)) && (pX>0 && pX <(iheight -1))){	   
        normal1 = calculaNormal(MatrizPontos[pX][pY+1],MatrizPontos[pX+1][pY],MatrizPontos[pX][pY] );
        normal2=  calculaNormal(MatrizPontos[pX][pY+1],MatrizPontos[pX][pY],MatrizPontos[pX-1][pY+1]);
        normal3=  calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX-1][pY],MatrizPontos[pX-1][pY+1]);
        normal4=  calculaNormal(MatrizPontos[pX+1][pY],MatrizPontos[pX+1][pY-1],MatrizPontos[pX][pY]);
        normal5=  calculaNormal(MatrizPontos[pX][pY-1],MatrizPontos[pX][pY], MatrizPontos[pX+1][pY-1]);
        normal6=  calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX][pY-1], MatrizPontos[pX-1][pY]);
      }  
      //Regiao 2
      else  if(pX == 0 && (pY == 0)){	   
        normal1 = calculaNormal(MatrizPontos[pX][pY+1],MatrizPontos[pX+1][pY],MatrizPontos[pX][pY] );
      }
      //Regiao 3
      else if((pY == 0) && (pX > 0 && pX < ( iheight -1))){
        normal1 = calculaNormal(MatrizPontos[pX][pY+1],MatrizPontos[pX+1][pY],MatrizPontos[pX][pY] );
      	normal2 =  calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX-1][pY],MatrizPontos[pX-1][pY+1]);
      }
      //Regiao 4
      else if (pY== 0 && (pX == (iheight-1))){
        normal1 = calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX-1][pY],MatrizPontos[pX-1][pY+1] );
        normal2=  calculaNormal(MatrizPontos[pX][pY+1],MatrizPontos[pX][pY],MatrizPontos[pX-1][pY+1]);
      }
      //Regiao 5
      else if(pX == 0 && (pY>0 && pY < (iwidth -1))){
        normal1=  calculaNormal(MatrizPontos[pX+1][pY],MatrizPontos[pX+1][pY-1],MatrizPontos[pX][pY] );
        normal2 = calculaNormal(MatrizPontos[pX][pY], MatrizPontos[pX][pY+1],MatrizPontos[pX+1][pY]);
      }
      //Regiao 6 
      else if((pX == (iheight-1)) && pY < (iwidth -1)){
        normal1=  calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX-1][pY],MatrizPontos[pX-1][pY+1]);
        normal2=  calculaNormal(MatrizPontos[pX][pY+1],MatrizPontos[pX][pY],MatrizPontos[pX-1][pY+1]);
        normal3=  calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX][pY-1], MatrizPontos[pX-1][pY]);
      }
      //Regiao 7
  		else if((pX == 0) && pY == (iwidth -1)){
        normal1=  calculaNormal(MatrizPontos[pX+1][pY],MatrizPontos[pX+1][pY-1],MatrizPontos[pX][pY]);
        normal2=  calculaNormal(MatrizPontos[pX][pY-1],MatrizPontos[pX][pY], MatrizPontos[pX+1][pY-1]);
      }
      //Regiao 8
      else if ((pX > 0 && pX < ( iheight -1)) && pY == (iwidth -1)){
        normal1=  calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX][pY-1], MatrizPontos[pX-1][pY]);
        normal2=  calculaNormal(MatrizPontos[pX+1][pY],MatrizPontos[pX+1][pY-1],MatrizPontos[pX][pY]);
        normal3=  calculaNormal(MatrizPontos[pX][pY-1],MatrizPontos[pX][pY], MatrizPontos[pX+1][pY-1]);
      }
			//Regiao 9
      else if ((pX == (iheight -1)) && pY == (iwidth -1)){
        normal1=  calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX][pY-1], MatrizPontos[pX-1][pY]);
      } 
      normalR = calculaNormalVertice(normal1,normal2,normal3,normal4,normal5,normal6);
			glNormal3f(normalR->posX,normalR->posY,normalR->posZ);
		
			
		
				if(typeVisualizacao == 1){
				  //       glBindTexture(GL_TEXTURE_2D, texName[0]);
				       /*

                      glEnable(GL_TEXTURE_2D);

				        if(coordX == 0.0f && coordY == 0.0f){
					  glEnd();
					 
		     if(MatrizPontos[pX][pY]->posY <= alturaMaximaAguaProfunda){
						   glBindTexture(GL_TEXTURE_2D, texName[0]);
						   textura = 0;

					}
					
					  else if(MatrizPontos[pX][pY]->posY > alturaMaximaAguaProfunda && MatrizPontos[pX][pY]->posY <= alturaMaximaAguaRasa ){
                                 glBindTexture(GL_TEXTURE_2D, texName[1]);
                                 textura = 1;
              
					}
					
					  else if(MatrizPontos[pX][pY]->posY > alturaMaximaAguaRasa && MatrizPontos[pX][pY]->posY <= alturaMaximaGrama ){

							glBindTexture(GL_TEXTURE_2D, texName[2]);
							textura =2 ;


					}
					
					else{
	                    glBindTexture(GL_TEXTURE_2D, texName[3]);
	                    textura = 3 ;

					} 
					
				}
			    
			    glBegin( GL_TRIANGLE_STRIP );
			    if((coordX == 0.0f && coordY == 0.0f) && (ponto1 != NULL && ponto2 != NULL)){
			    	glTexCoord2f(0.0f, 0.0f);
					glVertex3f(ponto1->posX,ponto1->posY,ponto1->posZ);
					glTexCoord2f(1.0f, 0.0f);
					glVertex3f(ponto2->posX,ponto2->posY,ponto2->posZ);
				    coordX = 0.0f;
					coordY = 1.0f;
				}
			   */
			    glTexCoord2f(coordX, coordY);
			    if(coordX == 0.0f && coordY == 0.0f){
					coordX = 1.0f;
				}
				else if(coordX == 1.0f && coordY == 1.0f){
					coordX = 0.0f;
					coordY = 0.0f;
				}
				
				else if(coordX == 1.0f && coordY == 0.0f){
					coordY = 1.0f;
					coordX = 0.0f;
				}
				else if(coordX == 0.0f && coordY == 1.0f){
					coordX = 1.0f;
					coordY = 1.0f;
				}
				
			   
		        }
		        
		        	
		        	glVertex3f(MatrizPontos[pX][pY]->posX,MatrizPontos[pX][pY]->posY,MatrizPontos[pX][pY]->posZ);
		        	ponto1 = MatrizPontos[pX][pY];
		        

			
			pX++;
            free(normal1);
			free(normal2);
			free(normal3);
			free(normal4);
			free(normal5);
			free(normal6);
			free(normalR);
			normal1 = NULL;
			normal2 = NULL;
			normal3 = NULL;
			normal4 = NULL;
			normal5= NULL;
			normal6 = NULL;
			normalR = NULL;
			//Regiao 1
			if((pY>0 && pY< (iwidth -1)) && (pX>0 && pX <(iheight -1))){	   
        normal1 = calculaNormal(MatrizPontos[pX][pY+1],MatrizPontos[pX+1][pY],MatrizPontos[pX][pY] );
			  normal2=  calculaNormal(MatrizPontos[pX][pY+1],MatrizPontos[pX][pY],MatrizPontos[pX-1][pY+1]);
			  normal3=  calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX-1][pY],MatrizPontos[pX-1][pY+1]);
			  normal4=  calculaNormal(MatrizPontos[pX+1][pY],MatrizPontos[pX+1][pY-1],MatrizPontos[pX][pY]);
			  normal5=  calculaNormal(MatrizPontos[pX][pY-1],MatrizPontos[pX][pY], MatrizPontos[pX+1][pY-1]);
			  normal6=  calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX][pY-1], MatrizPontos[pX-1][pY]);
      }
      //Regiao 2
      else  if(pX == 0 && (pY == 0)){	   
        normal1 = calculaNormal(MatrizPontos[pX][pY+1],MatrizPontos[pX+1][pY],MatrizPontos[pX][pY] );
      }
      //Regiao 3
      else if((pY == 0) && (pX > 0 && pX < ( iheight -1))){
        normal1 = calculaNormal(MatrizPontos[pX][pY+1],MatrizPontos[pX+1][pY],MatrizPontos[pX][pY] );
        normal2 =  calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX-1][pY],MatrizPontos[pX-1][pY+1]);
      }
      //Regiao 4
      else if (pY== 0 && (pX == (iheight-1))){
        normal1 = calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX-1][pY],MatrizPontos[pX-1][pY+1] );
        normal2=  calculaNormal(MatrizPontos[pX][pY+1],MatrizPontos[pX][pY],MatrizPontos[pX-1][pY+1]);
      }
      //Regiao 5
      else if(pX == 0 && (pY>0 && pY < (iwidth -1))){
        normal1=  calculaNormal(MatrizPontos[pX+1][pY],MatrizPontos[pX+1][pY-1],MatrizPontos[pX][pY] );
        normal2 = calculaNormal(MatrizPontos[pX][pY], MatrizPontos[pX][pY+1],MatrizPontos[pX+1][pY]);
      }
      //Regiao 6 
      else if((pX == (iheight-1)) && pY < (iwidth -1)){
        normal1=  calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX-1][pY],MatrizPontos[pX-1][pY+1]);
        normal2=  calculaNormal(MatrizPontos[pX][pY+1],MatrizPontos[pX][pY],MatrizPontos[pX-1][pY+1]);
        normal3=  calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX][pY-1], MatrizPontos[pX-1][pY]);
      }
			//Regiao 7
      else if((pX == 0) && pY == (iwidth -1)){
        normal1=  calculaNormal(MatrizPontos[pX+1][pY],MatrizPontos[pX+1][pY-1],MatrizPontos[pX][pY]);
        normal2=  calculaNormal(MatrizPontos[pX][pY-1],MatrizPontos[pX][pY], MatrizPontos[pX+1][pY-1]);
      }
      //Regiao 8
      else if ((pX > 0 && pX < ( iheight -1)) && pY == (iwidth -1)){
        normal1=  calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX][pY-1], MatrizPontos[pX-1][pY]);
        normal2=  calculaNormal(MatrizPontos[pX+1][pY],MatrizPontos[pX+1][pY-1],MatrizPontos[pX][pY]);
        normal3=  calculaNormal(MatrizPontos[pX][pY-1],MatrizPontos[pX][pY], MatrizPontos[pX+1][pY-1]);
      }
	   //Regiao 9
      else if ((pX == (iheight -1)) && pY == (iwidth -1)){
        normal1=  calculaNormal(MatrizPontos[pX][pY],MatrizPontos[pX][pY-1], MatrizPontos[pX-1][pY]);
      } 
      normalR = calculaNormalVertice(normal1,normal2,normal3,normal4,normal5,normal6);
			glNormal3f(normalR->posX,normalR->posY,normalR->posZ);
			
	   	
					
				if(typeVisualizacao == 1){
				  //       glBindTexture(GL_TEXTURE_2D, texName[0]);
		/*		       

                      glEnable(GL_TEXTURE_2D);

				        if(coordX == 0.0f && coordY == 0.0f){
					  glEnd();
					 
		     if(MatrizPontos[pX][pY]->posY <= alturaMaximaAguaProfunda){
						   glBindTexture(GL_TEXTURE_2D, texName[0]);

					}
					
					  else if(MatrizPontos[pX][pY]->posY > alturaMaximaAguaProfunda && MatrizPontos[pX][pY]->posY <= alturaMaximaAguaRasa ){
                                 glBindTexture(GL_TEXTURE_2D, texName[1]);
              
					}
					
					  else if(MatrizPontos[pX][pY]->posY > alturaMaximaAguaRasa && MatrizPontos[pX][pY]->posY <= alturaMaximaGrama ){

							glBindTexture(GL_TEXTURE_2D, texName[2]);


					}
					
					else{
	                    glBindTexture(GL_TEXTURE_2D, texName[3]);

					}
				}
			    
			    glBegin( GL_TRIANGLE_STRIP );
			    if(coordX == 0.0f && coordY == 0.0f && ponto1 != NULL && ponto2 != NULL){
			       glTexCoord2f(0.0f, 0.0f);
					glVertex3f(ponto1->posX,ponto1->posY,ponto1->posZ);
					glTexCoord2f(1.0f, 0.0f);
					glVertex3f(ponto2->posX,ponto2->posY,ponto2->posZ);
				    coordX = 0.0f;
					coordY = 1.0f;
				}
			   */
			    glTexCoord2f(coordX, coordY);
			    if(coordX == 0.0f && coordY == 0.0f){
					coordX = 1.0f;
				}
				else if(coordX == 1.0f && coordY == 1.0f){
					coordX = 0.0f;
					coordY = 0.0f;
				}
				
				else if(coordX == 1.0f && coordY == 0.0f){
					coordY = 1.0f;
					coordX = 0.0f;
				}
				else if(coordX == 0.0f && coordY == 1.0f){
					coordX = 1.0f;
					coordY = 1.0f;
				}
				
			   
		        }
		        
		        	
		        	glVertex3f(MatrizPontos[pX][pY]->posX,MatrizPontos[pX][pY]->posY,MatrizPontos[pX][pY]->posZ);
		        	ponto2 = MatrizPontos[pX][pY];

			    
	
	    
	    free(normal1);
	    free(normal2);
	    free(normal3);
	    free(normal4);
	    free(normal5);
	    free(normal6);
	    free(normalR);
	    normal1 = NULL;
	    normal2 = NULL;
	    normal3 = NULL;
	    normal4 = NULL;
	    normal5= NULL;
	    normal6 = NULL;
	    normalR = NULL;
	 }
	 glEnd();
  }
}

void imprimeMatrizPontos()
{
	int x,y,qt;
	qt = 0;
	for(x= 0; x < iheight ; x++){
    for(y= 0; y < iwidth ; y++){
      if(x > 2000){
        printf("X: %f Y: %f Z:%f\n",MatrizPontos[x][y]->posX,MatrizPontos[x][y]->posY,MatrizPontos[x][y]->posZ);
      }
    }
  }
}

void mapeiaImagem()
{
	int tamanhoLinha = iwidth * 3;
	int linha = 0;
	int pos = 0;
	int posLinha = 0;

	for(pos = 0; linha < iheight ; pos = pos +3){
		
		if((pos % tamanhoLinha == 0)){
			if(pos == 0){
		    posLinha = 0;
		    MatrizPontos[linha] = (Ponto **) malloc (iwidth * sizeof(Ponto*));
			}
			else{
			linha++;
		    posLinha = 0;
		    MatrizPontos[linha] = (Ponto **) malloc (iwidth * sizeof(Ponto*));
		    if(linha == iheight){
				break;
			}
		}
		    
		}
	
		float altura =  mapeiaAltura(image[pos]);
		
		Ponto *point = criaPonto(linha * distanciaPonto ,altura,posLinha * distanciaPonto);
		if(pos == 0){
       maiorX = point->posX;
       menorX = point->posX;
       maiorZ = point->posZ;
       menorZ = point->posZ;
       menorY = point->posY;
    }else{
      if(point->posX>maiorX)
        maiorX=point->posX;
      if(point->posX<menorX)
        menorX=point->posX;
      if(point->posZ>maiorZ)
        maiorZ=point->posZ;
      if(point->posZ<menorZ)
        menorZ=point->posZ;
      if(point->posY<menorY)
        menorY=point->posY;
    }
		if(altura > maiorAltura){
			maiorAltura = altura;
			pontoMaiorAltura = point;
			meuPontoX = linha;
			meuPontoZ = posLinha;
		}
		MatrizPontos[linha][posLinha] = point;
		posLinha++;
	}
}

// Inicializa parametros de rendering
void inicializa (void)
{ 
  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  glShadeModel(GL_SMOOTH);				  
  glEnable(GL_DEPTH_TEST);					   
  glEnable(GL_CULL_FACE);	

  glCullFace(GL_FRONT);  
  glFrontFace(GL_CCW);
  glEnable(GL_LIGHTING);
    
    if(typeVisualizacao == 0){
   
    GLfloat LuzAmbiente[]   = {0.0f, 0.1f, 0.0f } ;
	GLfloat LuzDifusa[]   = {0.9f, 0.9f, 0.9f, 1.0f };
	GLfloat LuzEspecular[] = {0.8f, 0.8f, 0.8f, 1.0f };
    glDisable(GL_TEXTURE_2D);
    }
    else if (typeVisualizacao == 1){
	
	GLfloat LuzAmbiente[]={0.7f,0.7f,0.7f,1.0f}; 
	GLfloat LuzDifusa[]={0.8f,0.8f,0.8f,1.0f};	   // "cor" 
	GLfloat LuzEspecular[]={1.0f, 1.0f, 1.0f, 1.0f};// "brilho" 
	


		
	}
    GLfloat Especularidade[] = {1.0f, 1.0f, 1.0f, 1.0f };
    GLfloat PosicaoLuz0[]  = {MatrizPontos[iheight/2][iwidth/2]->posX, pontoMaiorAltura->posY + 100, MatrizPontos[iheight/2][iwidth/2]->posZ, 1.0f };
  	// Ativa o uso da luz ambiente
	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, LuzAmbiente);
	// Define os parametros da Luz nÃºmero Zero
	glLightfv(GL_LIGHT0, GL_AMBIENT, LuzAmbiente);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, LuzDifusa  );
	glLightfv(GL_LIGHT0, GL_SPECULAR, LuzEspecular  );
	glLightfv(GL_LIGHT0, GL_POSITION, PosicaoLuz0 );
	glEnable(GL_LIGHT0);
		// Define a reflectancia do material
	glMaterialfv(GL_FRONT,GL_SPECULAR, Especularidade);

	// Define a concentraÃ§Ã£o do brilho.
	// Quanto maior o valor do Segundo parametro, mais
	// concentrado serÃ¡ o brilho. (Valores vÃ¡lidos: de 0 a 128)
	glMateriali(GL_FRONT,GL_SHININESS,50.2);
	glEnable(GL_COLOR_MATERIAL);
	

	
	   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glGenTextures(5, texName);
      
	//Textura 1
    image = glmReadPPM("Images/aguasProfundas.ppm", &iwidthTextura, &iheightTextura);

	glBindTexture(GL_TEXTURE_2D, texName[0]);
	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, iwidthTextura, iheightTextura,0, GL_RGB, GL_UNSIGNED_BYTE, image);
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,	GL_LINEAR);	
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,	GL_LINEAR);	
	
	/*glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,	GL_NEAREST);	
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,	GL_NEAREST);
	* */
	//	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,  GL_REPEAT);
   	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 	free(image);




	
	//Textura 2
	
	image = glmReadPPM("Images/aguasProximas.ppm", &iwidthTextura, &iheightTextura);
	glBindTexture(GL_TEXTURE_2D, texName[1]);
   	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, iwidthTextura, iheightTextura,0, GL_RGB, GL_UNSIGNED_BYTE, image);
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,	GL_LINEAR);	
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,	GL_LINEAR);		
	//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
	//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
	/*glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,	GL_NEAREST);	
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,	GL_NEAREST);
	* */
	//	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,  GL_REPEAT);
   	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 	free(image);
	
	



	
		//Textura 3
	
   image = glmReadPPM("Images/grama.ppm", &iwidthTextura, &iheightTextura);
	glBindTexture(GL_TEXTURE_2D, texName[2]);
		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, iwidthTextura, iheightTextura,0, GL_RGB, GL_UNSIGNED_BYTE, image);
	
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,	GL_LINEAR);	
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,	GL_LINEAR);	
	
	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,  GL_REPEAT);
   	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 	free(image);




		
	//Textura 4
	
	image = glmReadPPM("Images/pedras.ppm", &iwidthTextura, &iheightTextura);
	glBindTexture(GL_TEXTURE_2D, texName[3]);
		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, iwidthTextura, iheightTextura,0, GL_RGB, GL_UNSIGNED_BYTE, image);
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,	GL_LINEAR);	
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,	GL_LINEAR);		
	//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
	//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 	free(image);
 	
 	
 	//Textura 5
 	
 		image = glmReadPPM("Images/dunas.ppm", &iwidthTextura, &iheightTextura);
	    glBindTexture(GL_TEXTURE_2D, texName[4]);
		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, iwidthTextura, iheightTextura,0, GL_RGB, GL_UNSIGNED_BYTE, image);
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,	GL_LINEAR);	
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,	GL_LINEAR);		
	//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
	//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 	free(image);

	
  glRotatef(rtri,0.0f,1.0f,0.0f);			// Rotaciona incrementalmente no eixo Y
  glRotatef(-20.0f,1.0f,0.0f,0.0f);						    
  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  angle=90;
}

void mudaModoVisualizacao(){
	
		if(typeVisualizacao == 0){
		
	glDisable(GL_TEXTURE_2D);	
	GLfloat LuzAmbiente[]   = {0.0f, 0.1f, 0.0f } ;
	GLfloat LuzDifusa[]   = {0.9f, 0.9f, 0.9f, 1.0f };
	GLfloat LuzEspecular[] = {0.8f, 0.8f, 0.8f, 1.0f };
	GLfloat PosicaoLuz0[]  = {MatrizPontos[iheight/2][iwidth/2]->posX, pontoMaiorAltura->posY + 100, MatrizPontos[iheight/2][iwidth/2]->posZ, 1.0f };
  	// Ativa o uso da luz ambiente
	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, LuzAmbiente);
	// Define os parametros da Luz nÃºmero Zero
	glLightfv(GL_LIGHT0, GL_AMBIENT, LuzAmbiente);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, LuzDifusa  );
	glLightfv(GL_LIGHT0, GL_SPECULAR, LuzEspecular  );
	glLightfv(GL_LIGHT0, GL_POSITION, PosicaoLuz0 );
	glEnable(GL_LIGHT0);
		// Define a reflectancia do material
	glMaterialfv(GL_FRONT,GL_SPECULAR, Especularidade);

	// Define a concentraÃ§Ã£o do brilho.
	// Quanto maior o valor do Segundo parametro, mais
	// concentrado serÃ¡ o brilho. (Valores vÃ¡lidos: de 0 a 128)
	glMateriali(GL_FRONT,GL_SHININESS,50.2);
	glEnable(GL_COLOR_MATERIAL);
}

	
	
		else if (typeVisualizacao == 1){
      //  glDisable(GL_COLOR_MATERIAL);
       glEnable(GL_TEXTURE_2D);
       
	GLfloat LuzAmbiente[]={0.7f,0.7f,0.7f,1.0f}; 
	GLfloat LuzDifusa[]={0.8f,0.8f,0.8f,1.0f};	   // "cor" 
	GLfloat LuzEspecular[]={1.0f, 1.0f, 1.0f, 1.0f};// "brilho
       //glBindTexture(GL_TEXTURE_2D, texName[2]);
          GLfloat Especularidade[] = {1.0f, 1.0f, 1.0f, 1.0f };
    GLfloat PosicaoLuz0[]  = {MatrizPontos[iheight/2][iwidth/2]->posX, pontoMaiorAltura->posY + 100, MatrizPontos[iheight/2][iwidth/2]->posZ, 1.0f };
  	// Ativa o uso da luz ambiente
	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, LuzAmbiente);
	// Define os parametros da Luz nÃºmero Zero
	glLightfv(GL_LIGHT0, GL_AMBIENT, LuzAmbiente);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, LuzDifusa  );
	glLightfv(GL_LIGHT0, GL_SPECULAR, LuzEspecular  );
	glLightfv(GL_LIGHT0, GL_POSITION, PosicaoLuz0 );
	glEnable(GL_LIGHT0);
		// Define a reflectancia do material
	glMaterialfv(GL_FRONT,GL_SPECULAR, Especularidade);

	// Define a concentraÃ§Ã£o do brilho.
	// Quanto maior o valor do Segundo parametro, mais
	// concentrado serÃ¡ o brilho. (Valores vÃ¡lidos: de 0 a 128)
	glMateriali(GL_FRONT,GL_SHININESS,50.2);
	glEnable(GL_COLOR_MATERIAL);
       
 	
		
	}
	
	
}

void desenha(void)
{
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);


  int x;
  float  z = 0;
  glColor3f(1.0f, 1.0f, 1.0f);
 
	// Especifica sistema de coordenadas do modelo
	glMatrixMode(GL_MODELVIEW);
	// Inicializa sistema de coordenadas do modelo
  glLoadIdentity();
  glPushMatrix();
      printf("\nMinha posicao X %f Y %f Z %f\n", MatrizPontos[meuPontoX][meuPontoZ]->posX,   MatrizPontos[meuPontoX][meuPontoZ]->posY,  MatrizPontos[meuPontoX][meuPontoZ]->posZ);
  if(isAndando){
    if(flag){//se for a primeira exibiÃ§Ã£o
      meuX = pontoMaiorAltura->posX;
      meuY = pontoMaiorAltura->posY + alturaPessoa;
      meuZ = pontoMaiorAltura->posZ;
      pontoInicial = MatrizPontos[iheight/2][0];
    //  posicaoX = pontoInicial->posX;
      posicaoY = meuY;
     // posicaoZ = pontoInicial->posZ;
      posicaoX = MatrizPontos[0][iwidth/2]->posX;
      posicaoZ= MatrizPontos[0][iwidth/2]->posZ;
      gluLookAt(meuX,meuY,meuZ,posicaoX,meuY,posicaoZ,  0,1,0);  
     
      flag = 0;
      printf("posicaoX %f posicaoY %f posicaoZ %f\n",posicaoX,posicaoY,posicaoZ);
    }else{
      gluLookAt(meuX,meuY,meuZ,posicaoX,meuY,posicaoZ,  0,1,0);  
     /*  if(isRotate){
		  
	  }
	  * */
      printf("posicaoX %f posicaoY %f posicaoZ %f\n",posicaoX,posicaoY,posicaoZ);
    }
  }else{ 
    if(flag){//se for a primeira exibiÃ§Ã£o
      //meuX = pontoMaiorAltura->posX;
     // meuY = pontoMaiorAltura->posY;
      //meuZ = pontoMaiorAltura->posZ;
      meuX = pontoMaiorAltura->posX;
      meuY = pontoMaiorAltura->posY + alturaPessoa;
      meuZ = pontoMaiorAltura->posZ;
      pontoInicial = MatrizPontos[iheight/2][0];
     // posicaoX = pontoInicial->posX;
      posicaoY = meuY ;
     // posicaoZ = pontoInicial->posZ;
     posicaoX = MatrizPontos[0][iwidth/2]->posX;
     posicaoZ= MatrizPontos[0][iwidth/2]->posZ;
    
      gluLookAt(meuX,meuY,meuZ,posicaoX,posicaoY,posicaoZ,  0,1,0);  
      
      flag = 0;
      printf("posicaoX %f posicaoY %f posicaoZ %f\n",posicaoX,posicaoY,posicaoZ);
    }else{
      gluLookAt(meuX,meuY,meuZ,posicaoX,posicaoY,posicaoZ,  0,1,0);  
       /* if(isRotate){
		  
	  }
	  * */
      printf("posicaoX %f posicaoY %f posicaoZ %f\n",posicaoX,posicaoY,posicaoZ);
    }
  
  } 
 // glBegin( GL_TRIANGLE_STRIP );

  glBindTexture(GL_TEXTURE_2D, texName[3]);
  desenhaTriangulos();
    printf("chamado1\n");
 // glEnd();
	// Executa os comandos OpenGL
	  glPopMatrix();
	glutSwapBuffers();
 }
 
 
  void gerenciaTeclado(unsigned char key, int x, int y){
    printf("\nMinha posicao X %f Y %f Z %f\n", MatrizPontos[meuPontoX][meuPontoZ]->posX,   MatrizPontos[meuPontoX][meuPontoZ]->posY,  MatrizPontos[meuPontoX][meuPontoZ]->posZ);
    switch (key) {
            //controles da visao
            case 'Q': 
            case 'q':
                  printf("q\n");  
                  posicaoX= posicaoX-10000;
                  glutPostRedisplay();
                  break;
            case 'W':
            case 'w':
                  printf("w\n");
                  posicaoX= posicaoX+10000;
                  glutPostRedisplay();
                  break;
            case 'E':
            case 'e':
                  printf("e\n");
                  posicaoY = posicaoY-10000; 
                  glutPostRedisplay();
                  break;
            case 'R':
            case 'r':
                  printf("r\n");
                  posicaoY = posicaoY+10000;                  
                  glutPostRedisplay();
                  break;
            case 'T':
            case 't':
                  printf("t\n");
                  posicaoZ = posicaoZ - 10000;                  
                  glutPostRedisplay();
                  break;
            case 'Y':
            case 'y':
                  printf("y\n");
                  posicaoZ = posicaoZ + 10000;
                  glutPostRedisplay();
                  break;
            //controles do voo                  
            case 'A': 
            case 'a':
                  if(isAndando){
                  //  if( (meuX-distanciaPonto) >= menorX){
					  if(meuPontoX > 0){
                      printf("a\n");  
                      meuPontoX--;
                      meuX= MatrizPontos[meuPontoX][meuPontoZ]->posX;
                      meuZ= MatrizPontos[meuPontoX][meuPontoZ]->posZ;
                      meuY= MatrizPontos[meuPontoX][meuPontoZ]->posY + alturaPessoa;
                     
                      glutPostRedisplay();
                    }
                  }else{
                    //if( (meuX-velocidade) >= menorX){
                   // if( (meuX-distanciaPonto) >= menorX){
					     if(meuPontoX > 0){
                      printf("a\n");  
                      //meuX= meuX-velocidade;
                      //testando se altura Ã© valida
                   if( meuY > MatrizPontos[meuPontoX-1][meuPontoZ]->posY ){
                       meuPontoX--;
                      meuX= MatrizPontos[meuPontoX][meuPontoZ]->posX;
                      meuZ= MatrizPontos[meuPontoX][meuPontoZ]->posZ;
                    //  meuY= MatrizPontos[meuPontoX][meuPontoZ]->posY + alturaPessoa;
                        glutPostRedisplay();
                     }
                    }
                  }
                  break;
            case 'S':
            case 's':
                  if(isAndando){
                    //if( (meuX+distanciaPonto) <= maiorX){
						  if(meuPontoX < iheight -1){
                      printf("s\n");
                       meuPontoX++;
                      meuX= MatrizPontos[meuPontoX][meuPontoZ]->posX;
                      meuZ= MatrizPontos[meuPontoX][meuPontoZ]->posZ;
                      meuY= MatrizPontos[meuPontoX][meuPontoZ]->posY + alturaPessoa;
                     
                      glutPostRedisplay();
                    }
                  }else{
                    //if( (meuX+velocidade) < maiorX){
                   // if( (meuX+distanciaPonto) <= maiorX){
					 if(meuPontoX < iheight -1){
                      printf("s\n");
                      //meuX= meuX+velocidade;
                      //testando y
                    if( meuY > MatrizPontos[meuPontoX+1][meuPontoZ]->posY ){
                        meuPontoX++;
                      meuX= MatrizPontos[meuPontoX][meuPontoZ]->posX;
                      meuZ= MatrizPontos[meuPontoX][meuPontoZ]->posZ;
                    //  meuY= MatrizPontos[meuPontoX][meuPontoZ]->posY + alturaPessoa;
                      glutPostRedisplay();
                      }
                    }
                  }
                  
                  break;
            case 'D':
            case 'd':
                  if(isAndando){
                    
                  }else{
                    //if( (meuY  - velocidade) > (menorY + alturaPessoa) ){
                    if( MatrizPontos[meuPontoX][meuPontoZ]->posY < meuY - distanciaPonto ){
                      meuY= meuY-distanciaPonto;
                      printf("d\n");
                      //meuY = meuY-velocidade; 
                      glutPostRedisplay();
                    }
                  }
                  break;
            case 'F':
            case 'f':
                  if(isAndando){

                  }else{
                    printf("f\n");
                    //meuY = meuY+velocidade;
                    meuY= meuY+distanciaPonto;                
                    glutPostRedisplay();
                  }
                  break;
            case 'G':
            case 'g':
                  if(isAndando){
                    if( meuPontoZ > 0){
                      printf("s\n");
                      meuPontoZ--;
                      meuX= MatrizPontos[meuPontoX][meuPontoZ]->posX;
                      meuZ= MatrizPontos[meuPontoX][meuPontoZ]->posZ;
                      meuY= MatrizPontos[meuPontoX][meuPontoZ]->posY + alturaPessoa;
                      glutPostRedisplay();
                    }
                  }else{
                    //if( (meuZ - velocidade) > menorZ ){
                    if(meuPontoZ  > 0 ){
                      printf("g\n");
                      //meuZ = meuZ - velocidade;
                      //testando y
                      if( meuY > MatrizPontos[meuPontoX][meuPontoZ-1]->posY ){
                      meuPontoZ--;
                      meuX= MatrizPontos[meuPontoX][meuPontoZ]->posX;
                      meuZ= MatrizPontos[meuPontoX][meuPontoZ]->posZ;
                   //   meuY= MatrizPontos[meuPontoX][meuPontoZ]->posY + alturaPessoa;
                      glutPostRedisplay();
                      }                  
                    }
                  }
                  break;
            case 'H':
            case 'h':
                  if(isAndando){
                    if(meuPontoZ  < iwidth -1){
                      printf("s\n");
                      meuPontoZ++;
                      meuX= MatrizPontos[meuPontoX][meuPontoZ]->posX;
                      meuZ= MatrizPontos[meuPontoX][meuPontoZ]->posZ;
                      meuY= MatrizPontos[meuPontoX][meuPontoZ]->posY + alturaPessoa;
                      glutPostRedisplay();
                    }  
                  }else{
                    //if( (meuZ + velocidade) < maiorZ ){
                    if(meuPontoZ  < iwidth -1){
                      printf("h\n");
                      //meuZ = meuZ + velocidade;
                      //testando y
                      if( meuY > MatrizPontos[meuPontoX][meuPontoZ + 1]->posY ){
                       meuPontoZ++;
                      meuX= MatrizPontos[meuPontoX][meuPontoZ]->posX;
                      meuZ= MatrizPontos[meuPontoX][meuPontoZ]->posZ;
                   //   meuY= MatrizPontos[meuPontoX][meuPontoZ]->posY + alturaPessoa;
                      glutPostRedisplay();;
                      }
                    }
                  }
                  break;
            case 'Z':
            case 'z':
                  printf("z\n");
                  velocidade = velocidade - 10;
                  printf("velocidade %f\n",velocidade);
                  break;
            case 'X':
            case 'x':
                  printf("x\n");
                  velocidade = velocidade + 10;
                  printf("velocidade %f\n",velocidade);
                  break;
            case 'M':
            case 'm':
                  printf("m\n");
                  if(isAndando){
                    printf("deixou de andar para voar\n");
                    isAndando = 0;
                  }else{
                    printf("deixou de voar para andar\n");
                    isAndando = 1;
                    funcPousar();
                    glutPostRedisplay();  
                   
                  }
                   break;
                  
              case 'V':
              case 'v':
                    printf("mudando a textura\n");
                    typeVisualizacao = (typeVisualizacao +1) % 2;
                    mudaModoVisualizacao();
                    glutPostRedisplay();  
                    break;
                  
    }

} 


// FunÃ§Ã£o usada para especificar o volume de visualizaÃ§Ã£o
void especificaParametrosVisualizacao(void)
{
	// Especifica sistema de coordenadas de projeÃ§Ã£o
	glMatrixMode(GL_PROJECTION);
	// Inicializa sistema de coordenadas de projeÃ§Ã£o
	glLoadIdentity();

	// Especifica a projeÃ§Ã£o perspectiva
	//gluPerspective(angle,fAspect,0.1,500);
  
    gluPerspective(40,1,0.2,100000);
	// Especifica sistema de coordenadas do modelo


	// Especifica posiÃ§Ã£o do observador e do alvo
	// gluLookAt(meuX,meuY,meuZ,posicaoX,posicaoY,posicaoZ,  0,1,0);  
}


// FunÃ§Ã£o callback chamada quando o tamanho da janela ÃƒÂƒÃ‚Â© alterado 
void alteraTamanhoJanela(GLsizei w, GLsizei h)
{
	// Para previnir uma divsÃ£o por zero
	if ( h == 0 ) h = 1;

	// Especifica o tamanho da viewport
	glViewport(0, 0, w, h);
 
	// Calcula a correÃ§Ã£o de aspecto
	fAspect = (GLfloat)w/(GLfloat)h;

	especificaParametrosVisualizacao();
}

// FunÃ§Ã£o callback chamada para gerenciar eventos do mouse
void gerenciaMouse(int button, int state, int x, int y)
{
	if (button == GLUT_LEFT_BUTTON)
		if (state == GLUT_DOWN) {  // Zoom-in
			if (angle >= 10) angle -= 5;
		}
	if (button == GLUT_RIGHT_BUTTON)
		if (state == GLUT_DOWN) {  // Zoom-out
			if (angle <= 130) angle += 5;
		}
	especificaParametrosVisualizacao();
	glutPostRedisplay();
}



int main(int argc, char **argv){
  //lendo nome do arquivo
  char *filename;
  if(argc >= 2)
    filename = argv[1];
  else{
    printf("parametro setado incorretamente\n");
    exit(1);  
  }
  alturaInicial = atof(argv[2]); //-28;//284;//0;
  distanciaPonto = atof(argv[3]);//30.23;//60;//160;
  amplitudeAltura = atof(argv[4]);//1.17; //10.004;//0.1;
  maiorAltura = 0;
  
  //comeÃ§a andando
  isAndando = 1;
  
  
  
  //carrega imagem
  image = glmReadPPM(filename, &iwidth, &iheight);
  MatrizPontos = (Ponto ***) malloc (iheight * sizeof(Ponto **));
  //controi-se uma matriz com todos os pontos da imagem
  mapeiaImagem();
  printf("maior altura%f\n",maiorAltura);
	if(iheight > 2 && iwidth >2){
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
    glutInitWindowSize(600,480);
    glutCreateWindow ("Tela 3D");
    inicializa();
    glutDisplayFunc(desenha);
    glutReshapeFunc(alteraTamanhoJanela);
    glutMouseFunc(gerenciaMouse);
    glutKeyboardFunc(gerenciaTeclado); 
    //especificaParametrosVisualizacao();
    glutMainLoop();
	}
}


